/*
 * UVa 227
 * Puzzle
 */
// 有一个 5*5 的网格，
// 其中恰好有一个格子是空的，其他格子各有一个字母。
// 一共有 4 种指令：A,B,L,R，
// 分别表示把空格上、下、左、右的相邻字母移到空格中。
// 输入初始网格和指令序列（以数字 0 结束），
// 输出指令执行完毕后的网格。
// 如果有非法指令，应输出 “This puzzle has no final configuration.”。
// 例如，下左图中执行 ARRBBL0 后，效果右图所示。
/*
T R G S J       T R G S J
X D O K I       X O K L I
M   V L N       M D V B N
W P A B E       W P   A E
U Q H C F       U Q H C F

样例输入：
TRGSJ
XDOKI
M VLN
WPABE
UQHCF
ARRBBL0
ABCDE
FGHIJ
KLMNO
PQRS
TUVWX
AAA
LLLL0
ABCDE
FGHIJ
KLMNO
PQRS
TUVWX
AAAAABBRRRLL0
Z
样例输出：
Puzzle #1:
T R G S J
X O K L I
M D V B N
W P   A E
U Q H C F

Puzzle #2:
  A B C D
F G H I E
K L M N J
P Q R S O
T U V W X

Puzzle #3:
This puzzle has no final configuration.
*/

// my answer: WA
// 在 UVa 上提交，结果为 WA
// 甚至别人的答案（见下面）都没有我的答案容错性好
#include <iostream>
#define LOCAL
using namespace std;
char puzzle[5][5]; // 格子
int main()
{
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    int ch,           // 存字符
        count = 0,    // 控制字符存入 puzzle
        amount = 0,   // puzzle 数
        x = 0, y = 0; // 空格子的坐标
    while ((ch = getchar()) != 'Z')
    {
        if (count < 25)
        {
            // 将字符存入 puzzle，同时找出空格子
            int row = count / 5,    // 行
                column = count % 5; // 列
            if (ch != '\n' || column)
            {
                // 空格子可能在一行末尾，
                // 比如 ABCD\n，注意不是 ABCD \n
                if (ch == ' ' || ch == '\n')
                {
                    x = row;
                    y = column;
                }
                puzzle[row][column] = ch;
                ++count;
            }
        }
        else
        {
            // 移动格子
            switch (ch)
            {
            case 'A':
                puzzle[x][y] = puzzle[x - 1][y];
                --x;
                break;
            case 'B':
                puzzle[x][y] = puzzle[x + 1][y];
                ++x;
                break;
            case 'L':
                puzzle[x][y] = puzzle[x][y - 1];
                --y;
                break;
            case 'R':
                puzzle[x][y] = puzzle[x][y + 1];
                ++y;
                break;
            case '0':
                // 一轮 puzzle 结束，输出
                count = 0;
                puzzle[x][y] = ' ';
                printf("Puzzle #%d:\n", ++amount);
                for (int i = 0; i < 5; ++i)
                    for (int j = 0; j < 5; ++j)
                        if (j == 4)
                            printf("%c\n", puzzle[i][j]);
                        else
                            printf("%c ", puzzle[i][j]);
                break;
            default:
                break;
            }
            // 检查是否把格子移出界限，是则输出
            if (x < 0 || x > 5 || y < 0 || y > 5)
            {
                printf("Puzzle #%d:\n"
                       "This puzzle has no final configuration.\n",
                       ++amount);
                // 归零处理
                count = 0;
                x = y = 0;
                while ((ch = getchar()) != '0')
                    ;
            }
        }
        if (count == 3 && amount)
            // 输出格式控制，
            // 保证 puzzle 之间有空行，
            // 且输出最后最多只有一个空行
            putchar('\n');
    }
    return 0;
}

// passed answer
// 别人的答案，提交后可以通过测试
// #include <stdio.h>
// #include <string.h>
// #define SWAP(a, b) ((a) ^= (b) ^= (a) ^= (b)) // 这样更块
// char map[10][10];
// char op[10086];
// #define print(j, k)             \
//     for (j = 0; j < 5; j++)     \
//     {                           \
//         for (k = 0; k < 5; k++) \
//         {                       \
//             putchar(map[j][k]); \
//             if (k != 4)         \
//                 putchar(' ');   \
//         }                       \
//         putchar('\n');          \
//     }
// int main()
// {
//     freopen("in.txt", "r", stdin);
//     freopen("out.txt", "w", stdout);
//     int i, j, k, si, sj, flag = 0, cnt = 0;
//     int is13 = 0, isFirst = 1; // 特判避免多输出换行
//     while (++cnt)
//     {
//         is13 = 0; // 用于特判空格在末尾会读入换行
//         si = -1, sj = -1;
//         flag = 0;
//         for (i = 0; i < 5; i++)
//         {
//             for (j = 0; j < 5; j++)
//             {
//                 map[i][j] = getchar();
//                 if (map[i][0] == 'Z')
//                     return 0;
//                 if (!map[i][j] || map[i][j] == '\n' || map[i][j] == '\r')
//                     map[i][j] = ' ', is13 = 1;
//                 if (map[i][j] == ' ')
//                 {
//                     if (si != -1 && sj != -1)
//                         flag = 1;
//                     // 特判多个空格
//                     si = i, sj = j;
//                 }
//             }
//             if (!is13)
//                 getchar();
//         }
//         i = 0;
//         while (op[i] = getchar()) // 读入操作
//         {
//             if (op[i] == '0')
//                 break;
//             if (op[i] == '\n' || op[i] == '\r')
//                 i--;
//             i++;
//         }
//         getchar();
//         i = 0;
//         if (!flag)
//             while (op[i] != '0') // 简单的模拟,不解释
//             {
//                 if (op[i] == 'A')
//                 {
//                     if (si == 0)
//                     {
//                         flag = 1;
//                         break;
//                     }
//                     SWAP(map[si][sj], map[si - 1][sj]);
//                     si--;
//                 }
//                 else if (op[i] == 'B')
//                 {
//                     if (si == 4)
//                     {
//                         flag = 1;
//                         break;
//                     }
//                     SWAP(map[si][sj], map[si + 1][sj]);
//                     si++;
//                 }
//                 else if (op[i] == 'L')
//                 {
//                     if (sj == 0)
//                     {
//                         flag = 1;
//                         break;
//                     }
//                     SWAP(map[si][sj], map[si][sj - 1]);
//                     sj--;
//                 }
//                 else if (op[i] == 'R')
//                 {
//                     if (sj == 4)
//                     {
//                         flag = 1;
//                         break;
//                     }
//                     SWAP(map[si][sj], map[si][sj + 1]);
//                     sj++;
//                 }
//                 else
//                 {
//                     flag = 1;
//                     break;
//                 }
//                 i++;
//             }
//         if (isFirst) // 特判要不要换行
//             isFirst = 0;
//         else
//             putchar('\n');
//         printf("Puzzle #%d:\n", cnt);
//         if (flag)
//             printf("This puzzle has no final configuration.\n");
//         else
//             print(j, k);
//     }
//     return 0;
// }